function AllReady() {
    const mstform = Ext.getCmp("KC_INKSYSBZTL_Head")
    const dgrid1 = Ext.getCmp("KC_INKSYSBZTL_Body")

    if (otype == 'add') {
        mstform.getItem("user_cllx").setValue("01")
    }


    const hideKey = ['user_bhsjexx', 'user_hsjexx',]
    hideKey.forEach(el => {
        mstform.getItem(el).addListener('change', function () {//值发生变化后立即触发
            mstform.getItem("user_hsjey").setValue(toChineseRMB(mstform.getItem("user_hsjexx").getValue()))
            mstform.getItem("user_bhsjey").setValue(toChineseRMB(mstform.getItem("user_bhsjexx").getValue()))
        });
    })

    dgrid1.addListener('edit', async function (store, eOpts) {
        console.log(`dgrid1.store`, dgrid1.store);
        const dstore = dgrid1.getStore()
        let total_amt = 0
        let total_amt_vat = 0
        for (var i = 0; i < dstore.getCount(); i++) {
            const record = dstore.getAt(i)
            console.log(`测试`, record.get("Mony"), record.get("TaxMony"));
            total_amt += (Number(record.get("Mony")) || 0)
            total_amt_vat += (Number(record.get("TaxMony")) || 0)
        }
        mstform.getItem("user_bhsjexx").setValue(total_amt)
        mstform.getItem("user_hsjexx").setValue(total_amt_vat)
    });



    // 获取主材出库的xinxi
    function getZcCkInfoByPhid() {
        const phid = mstform.getItem("user_ckdbm").getValue()
        if (!phid) return
        execServer("getZcCkInfoByPhid", { phid }, (res) => {
            const datas = JSON.parse(res.data)[0].extendObjects
            const arr = [
                ["PhidTrProj", datas.phid_pc],
                ["PhidWarehouse", datas.phid_warehouse],
                ["PhidClassno", datas.phid_classno],
                ["Tempflg", datas.tempflg], // 不存在
                ["user_cklx", datas.user_cllx],
                ["user_fbht", datas.user_htmc],
                ["user_fbd", datas.user_fbd],
                ["user_hsjexx", datas.user_hsjexx],
                ["user_hsjey", datas.user_hsjey],
                ["user_bhsjexx", datas.user_bhsjexx],
                ["user_bhsjey", datas.user_bhsjey]
            ]
            setHeadValues(arr, ['PhidTrProj', 'PhidWarehouse', 'PhidClassno'])
        })

    }



    mstform.getItem("user_ckdbm").addListener('change', function () {//值发生变化后立即触发
        getZcCkInfoByPhid()
    });
    mstform.on('dataready', function () {
        fpHidden()
    })

    // 赋值
    function setHeadValues(arr, helpKey) {
        arr.forEach(item => {
            try {
                mstform.getItem(item[0]).setValue(item[1])
            } catch (er) {
                console.log(`赋值字段发生错误${item}`, er);
            }
        })
        helpKey.forEach(key => {
            BatchBindCombox([mstform.getItem(key)])
        })
    }

    /**
* 将数字金额转换为中文大写（人民币格式）
* 最大值：10万亿（10,000,000,000,000），支持两位小数（角、分）
*
* 返回示例：
*   toChineseRMB(123456789.52) -> "壹亿贰仟叁佰肆拾伍万陆仟柒佰捌拾玖元伍角贰分"
*   toChineseRMB(0) -> "零元整"
*
* 如果超出范围或非法输入，会抛出 Error。
*/
    function toChineseRMB(input) {
        const MAX_INTEGER = 10_000_000_000_000; // 10万亿 = 10 * 10^12

        if (input === null || input === undefined || input === '') {
            throw new Error('请输入金额');
        }

        // 接受 number 或 string；先把它标准化为字符串（避免浮点精度问题）
        let str = (typeof input === 'number') ? input.toString() : String(input).trim();

        // 去掉千位分隔符等常见字符
        str = str.replace(/,/g, '');

        // 校验是否为合法的数字格式（可带两位或更多小数，后面会四舍五入到分）
        if (!/^-?\d+(\.\d+)?$/.test(str)) {
            throw new Error('非法数字格式');
        }

        // 不允许负数
        if (str.startsWith('-')) {
            throw new Error('不支持负数金额');
        }

        // 四舍五入到分（2 位小数）
        // 为避免浮点问题，按字符串处理：保留三位并四舍五入，或使用 BigInt 级处理
        const parts = str.split('.');
        const intPartStr = parts[0] || '0';
        let fracStr = parts[1] || '';

        // 将小数部分处理为两位四舍五入
        // 先补足到至少3位，便于判断四舍五入（若长度<3补0）
        fracStr = (fracStr + '000').slice(0, 3);
        // 判断第三位用于四舍五入
        const roundDigit = parseInt(fracStr[2], 10);
        let fracTwo = parseInt(fracStr.slice(0, 2), 10);
        if (roundDigit >= 5) fracTwo += 1;
        if (fracTwo >= 100) { // 进位到整数部分
            // 将整数部分加 1
            const intBig = BigInt(intPartStr || '0') + 1n;
            if (intBig > BigInt(MAX_INTEGER)) {
                throw new Error(`超过最大允许金额：${MAX_INTEGER}`);
            }
            // 更新整数与小数
            str = intBig.toString();
            // 小数置为 0
            fracTwo = 0;
        } else {
            str = intPartStr;
        }

        // 整数部分数字（去前导零）
        const intStrClean = str.replace(/^0+/, '') || '0';
        const intBigInt = BigInt(intStrClean);

        if (intBigInt > BigInt(MAX_INTEGER)) {
            throw new Error(`超过最大允许金额：${MAX_INTEGER}`);
        }

        // 数字到中文映射
        const CN_NUM = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
        const CN_UNIT_SMALL = ['', '拾', '佰', '仟']; // 个、十、百、千（按位）
        const CN_UNIT_BIG = ['', '万', '亿', '万亿'];  // 每四位一组
        const CN_DOLLAR = '元';
        const CN_JIAO = '角';
        const CN_FEN = '分';
        const CN_INTEGER_SUFFIX = '整';

        // 处理整数部分（每四位一组）
        function integerToCN(numStr) {
            if (numStr === '0') return '零';
            const chars = numStr.split('').reverse(); // 低位在前
            let groups = [];
            for (let i = 0; i < chars.length; i += 4) {
                groups.push(chars.slice(i, i + 4).reverse().join('')); // 每组四位，顺序为高->低组内仍高在前
            }
            // groups 是低位组在前，例如 ["0123","4567", ...] 低位先
            let resultParts = [];
            for (let gi = 0; gi < groups.length; gi++) {
                const group = groups[gi];
                const groupNum = parseInt(group, 10);
                if (groupNum === 0) {
                    resultParts.push(''); // 空占位，用于 later zero handling
                    continue;
                }
                // 处理单组四位
                let groupStr = '';
                const digits = group.padStart(4, '0').split('');
                for (let i = 0; i < 4; i++) {
                    const d = parseInt(digits[i], 10);
                    const pos = 4 - i - 1; // 对应 小单位索引
                    if (d === 0) {
                        // 只有当后面存在非零位时，才加一个零（避免重复）
                        // 检查后面是否还有非零位
                        const hasNonZeroAfter = digits.slice(i + 1).some(ch => ch !== '0');
                        if (hasNonZeroAfter) groupStr += '零';
                    } else {
                        groupStr += CN_NUM[d] + CN_UNIT_SMALL[pos];
                    }
                }
                // 去掉尾部可能的'零'
                groupStr = groupStr.replace(/零+$/, '');
                // 加上大单位（万/亿/万亿）
                groupStr += CN_UNIT_BIG[gi];
                resultParts.push(groupStr);
            }
            // 现在 resultParts 低位组在前，反转拼接，高位在前
            // 需要在拼接时处理跨组的零：如果高位组存在而低位组开头是空（即全0），并且上一已输出不以"零"结尾，则要在中间加"零"
            let final = '';
            for (let i = resultParts.length - 1; i >= 0; i--) {
                const segment = resultParts[i];
                if (!segment) {
                    // 当前组全零，若 final 不是空且不以零结尾，则需要在后续遇到非空组时插入"零"
                    final += '〈Z〉'; // 临时占位，用于统一去重
                } else {
                    final += segment;
                }
            }
            // 把占位压缩为单个零并清理边界
            final = final.replace(/〈Z〉+/g, '零');
            final = final.replace(/^零+/, ''); // 开头去零
            final = final.replace(/零$/, '');  // 结尾去零
            return final;
        }

        const cnInt = integerToCN(intStrClean);

        // 处理小数部分（角分）
        const jiao = Math.floor(fracTwo / 10);
        const fen = fracTwo % 10;

        let fracPartCN = '';
        if (jiao === 0 && fen === 0) {
            fracPartCN = CN_INTEGER_SUFFIX;
        } else {
            if (jiao > 0) fracPartCN += CN_NUM[jiao] + CN_JIAO;
            if (fen > 0) fracPartCN += CN_NUM[fen] + CN_FEN;
        }

        // 整体组合
        let result = '';
        if (cnInt === '零') {
            result = '零' + CN_DOLLAR;
        } else {
            result = cnInt + CN_DOLLAR;
        }

        if (fracPartCN === CN_INTEGER_SUFFIX) {
            result += CN_INTEGER_SUFFIX;
        } else {
            result += fracPartCN;
        }

        return result;
    }
}